/**
 * 全局错误处理工具
 * 用于屏蔽和优雅处理各种错误，提升用户体验
 */

// 错误屏蔽配置
const ERROR_CONFIG = {
  // 需要屏蔽的错误关键词
  BLOCKED_ERRORS: [
    'echarts',
    'Cannot read properties of undefined',
    'reading \'type\'',
    'webpack-internal',
    'node_modules/echarts'
  ],
  
  // 需要屏蔽的错误类型
  BLOCKED_ERROR_TYPES: [
    'TypeError',
    'ReferenceError'
  ]
}

/**
 * 检查错误是否应该被屏蔽
 * @param {Error} error - 错误对象
 * @returns {boolean} 是否应该屏蔽
 */
function shouldBlockError(error) {
  if (!error) return false
  
  const errorMessage = error.message || ''
  const errorStack = error.stack || ''
  const errorName = error.name || ''
  
  // 检查错误消息和堆栈是否包含需要屏蔽的关键词
  const hasBlockedKeyword = ERROR_CONFIG.BLOCKED_ERRORS.some(keyword => 
    errorMessage.includes(keyword) || errorStack.includes(keyword)
  )
  
  // 检查错误类型是否在屏蔽列表中
  const hasBlockedType = ERROR_CONFIG.BLOCKED_ERROR_TYPES.includes(errorName)
  
  return hasBlockedKeyword || hasBlockedType
}

/**
 * 初始化全局错误处理
 */
export function initGlobalErrorHandler() {
  // 屏蔽 JavaScript 错误
  window.addEventListener('error', function(event) {
    if (shouldBlockError(event.error)) {
      console.warn('错误已被屏蔽:', event.error.message)
      event.preventDefault()
      event.stopPropagation()
      return false
    }
  })
  
  // 屏蔽未捕获的 Promise 错误
  window.addEventListener('unhandledrejection', function(event) {
    if (shouldBlockError(event.reason)) {
      console.warn('Promise 错误已被屏蔽:', event.reason.message)
      event.preventDefault()
      return false
    }
  })
  
  // 屏蔽控制台错误（开发环境）
  if (process.env.NODE_ENV === 'development') {
    const originalConsoleError = console.error
    console.error = function(...args) {
      const errorMessage = args.join(' ')
      if (ERROR_CONFIG.BLOCKED_ERRORS.some(keyword => errorMessage.includes(keyword))) {
        console.warn('控制台错误已被屏蔽:', errorMessage)
        return
      }
      originalConsoleError.apply(console, args)
    }
  }
}

/**
 * 安全执行函数，自动捕获和屏蔽错误
 * @param {Function} fn - 要执行的函数
 * @param {*} fallback - 出错时的返回值
 * @returns {*} 函数执行结果或fallback值
 */
export function safeExecute(fn, fallback = null) {
  try {
    return fn()
  } catch (error) {
    if (shouldBlockError(error)) {
      console.warn('函数执行错误已被屏蔽:', error.message)
      return fallback
    }
    throw error
  }
}

/**
 * 安全执行异步函数
 * @param {Function} asyncFn - 要执行的异步函数
 * @param {*} fallback - 出错时的返回值
 * @returns {Promise} 异步函数执行结果或fallback值
 */
export async function safeExecuteAsync(asyncFn, fallback = null) {
  try {
    return await asyncFn()
  } catch (error) {
    if (shouldBlockError(error)) {
      console.warn('异步函数执行错误已被屏蔽:', error.message)
      return fallback
    }
    throw error
  }
}

/**
 * 创建防抖函数，避免频繁调用导致的错误
 * @param {Function} fn - 要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function createDebouncedFunction(fn, delay = 300) {
  let timeoutId = null
  
  return function(...args) {
    if (timeoutId) {
      clearTimeout(timeoutId)
    }
    
    timeoutId = setTimeout(() => {
      safeExecute(() => fn.apply(this, args))
    }, delay)
  }
}

/**
 * 创建节流函数，限制函数调用频率
 * @param {Function} fn - 要节流的函数
 * @param {number} limit - 时间限制（毫秒）
 * @returns {Function} 节流后的函数
 */
export function createThrottledFunction(fn, limit = 100) {
  let inThrottle = false
  
  return function(...args) {
    if (!inThrottle) {
      safeExecute(() => fn.apply(this, args))
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}
